import User from '../models/User.js';
import bcrypt from 'bcryptjs';
import jwt from 'jsonwebtoken';
import {
  connectRedis,
  storeVerificationCode,
  getVerificationCode,
  deleteVerificationCode,
  canSendNewVerificationCode,
  getRemainingWaitTime
} from '../utils/redisClient.js';
import {
  sendVerificationCode as sendEmailVerification,
  sendRegistrationSuccessEmail,
  verifyCode
} from '../utils/emailService.js';

// 密码强度验证
function validatePasswordStrength(password) {
  // 8-18个字符，只能包含字母、数字和特殊字符
  const passwordRegex = /^[a-zA-Z0-9\W_]{8,18}$/;
  const isValid = passwordRegex.test(password);
  const hasValidLength = password.length >= 8 && password.length <= 18;
  const hasValidFormat = /^[a-zA-Z0-9\W_]+$/.test(password);

  return {
    isValid: isValid,
    requirements: {
      length: hasValidLength,
      format: hasValidFormat
    }
  };
}

// 邮箱格式验证
function isValidEmail(email) {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return emailRegex.test(email);
}

// 账号格式验证
function isValidAccount(account) {
  // 账号只能包含数字字符，长度8-12
  const accountRegex = /^[0-9]{8,12}$/;
  return accountRegex.test(account);
}

// 初始化Redis连接（只连接一次）
let redisConnected = false;
async function initializeRedis() {
  if (!redisConnected) {
    redisConnected = await connectRedis();
  }
  return redisConnected;
}

// 发送邮箱验证码
export const sendVerificationCode = async (req, res) => {
  try {
    const { email, account, name } = req.body;

    if (!email) {
      return res.status(400).json({ message: '邮箱不能为空' });
    }

    if (!isValidEmail(email)) {
      return res.status(400).json({ message: '邮箱格式不正确' });
    }

    // 初始化Redis
    const isRedisConnected = await initializeRedis();
    if (!isRedisConnected) {
      console.warn('Redis未连接，使用备用方案');
    }

    // 检查邮箱是否已被注册
    const existingUser = await User.findOne({ email });
    if (existingUser) {
      return res.status(400).json({ message: '该邮箱已被注册' });
    }

    // 检查账号是否已被注册
    if (account) {
      const accountUser = await User.findOne({ account });
      if (accountUser) {
        return res.status(400).json({ message: '该账号已被注册' });
      }
    }

    // 生成临时用户ID用于验证码存储
    const tempUserId = `temp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;

    // 检查是否可以发送新的验证码
    const canSend = await canSendNewVerificationCode(tempUserId);
    if (!canSend) {
      const remainingTime = await getRemainingWaitTime(tempUserId);
      return res.status(429).json({
        message: `验证码发送过于频繁，请${remainingTime}秒后再试`
      });
    }

    // 发送验证码邮件
    const emailResult = await sendEmailVerification(email, tempUserId, name);

    if (!emailResult.success) {
      return res.status(500).json({
        message: '发送验证码失败',
        error: emailResult.error || '邮件服务暂时不可用'
      });
    }

    // 存储验证码到Redis
    await storeVerificationCode(tempUserId, email, emailResult.code);

    res.status(200).json({
      message: '验证码已发送到您的邮箱',
      email: email,
      tempUserId: tempUserId,
      expiresIn: 300 // 5分钟有效期
    });
  } catch (error) {
    console.error('发送验证码错误:', error);
    res.status(500).json({ message: '服务器错误', error: error.message });
  }
};

// 用户注册
export const register = async (req, res) => {
  try {
    const {
      name,
      account,
      email,
      password,
      verificationCode,
      tempUserId
    } = req.body;

    // 表单验证
    if (!name || !account || !email || !password || !verificationCode) {
      return res.status(400).json({ message: '请填写所有必填字段' });
    }

    // 用户名长度验证
    if (name.length > 8) {
      return res.status(400).json({ message: '用户名不能超过8个字符' });
    }

    // 账号格式验证
    if (!isValidAccount(account)) {
      return res.status(400).json({ message: '账号格式不正确，只能包含数字字符，长度8-12位' });
    }

    // 邮箱格式验证
    if (!isValidEmail(email)) {
      return res.status(400).json({ message: '邮箱格式不正确' });
    }

    // 密码强度验证
    const passwordValidation = validatePasswordStrength(password);
    if (!passwordValidation.isValid) {
      const issues = [];
      if (!passwordValidation.requirements.length) issues.push('密码长度8-18个字符');
      if (!passwordValidation.requirements.format) issues.push('密码只能包含字母、数字和特殊字符');
      return res.status(400).json({
        message: '密码格式不正确',
        requirements: issues
      });
    }



    // 检查账号是否已被注册
    const existingAccount = await User.findOne({ account });
    if (existingAccount) {
      return res.status(400).json({ message: '该账号已被注册' });
    }

    // 检查邮箱是否已被注册
    const existingEmail = await User.findOne({ email });
    if (existingEmail) {
      return res.status(400).json({ message: '该邮箱已被注册' });
    }

    // 初始化Redis
    const isRedisConnected = await initializeRedis();
    if (!isRedisConnected) {
      return res.status(503).json({ message: '验证码服务暂时不可用，请稍后再试' });
    }

    // 验证邮箱验证码
    // 首先尝试用tempUserId获取验证码，如果失败再尝试用email获取
    let storedCode = await getVerificationCode(tempUserId, false);
    if (!storedCode) {
      storedCode = await getVerificationCode(email, true);
    }
    
    if (!storedCode) {
      return res.status(400).json({ message: '验证码不存在或已过期' });
    }

    if (!verifyCode(storedCode, verificationCode)) {
      return res.status(400).json({ message: '验证码错误' });
    }

    // 加密密码
    const hashedPassword = await bcrypt.hash(password, 12);

    // 创建新用户
    const newUser = new User({
      name,
      account,
      email,
      password: hashedPassword,
      // 使用src/assets/avatars目录下的Scorpio图片
      
      avatar: 'src/assets/avatars/Scorpio.png',
      gender: 'unknown',
      birth: new Date('2000-01-01')
    });

    await newUser.save();

    // 清除验证码
    await deleteVerificationCode(tempUserId || newUser._id, email);

    // 异步发送注册成功邮件（不阻塞响应）
    sendRegistrationSuccessEmail(email, name).catch(err => {
      console.error('发送注册成功邮件失败:', err);
    });

    res.status(201).json({
      message: '注册成功',
      user: {
        id: newUser.id,
        name: newUser.name,
        account: newUser.account,
        email: newUser.email,
        avatar: newUser.avatar
      },
      redirectTo: '/login'
    });
  } catch (error) {
    console.error('注册错误:', error);
    res.status(500).json({ message: '服务器错误', error: error.message });
  }
};

// 用户登录
export const login = async (req, res) => {
  try {
    const { account, password, rememberMe = false } = req.body;

    if (!account || !password) {
      return res.status(400).json({ message: '请输入账号和密码' });
    }

    // 查找用户（支持账号登录）
    const user = await User.findOne({ account });
    if (!user) {
      return res.status(401).json({ message: '账号或密码错误' });
    }

    // 验证密码
    const isPasswordValid = await bcrypt.compare(password, user.password);
    if (!isPasswordValid) {
      return res.status(401).json({ message: '账号或密码错误' });
    }

    // 生成token
    const token = jwt.sign(
      { userId: user._id },
      process.env.JWT_SECRET,
      { expiresIn: process.env.JWT_EXPIRES_IN }
    );

    // 构建响应用户信息
    const userInfo = {
      id: user.id,
      name: user.name,
      account: user.account,
      email: user.email,
      avatar: user.avatar
    };

    // 如果用户需要记住账号，可以在前端处理（后端只返回必要信息）
    res.json({
      message: '登录成功',
      token,
      user: userInfo,
      rememberMe,
      redirectTo: '/'
    });
  } catch (error) {
    console.error('登录错误:', error);
    // 登录失败时提供适当的错误信息，但不暴露具体原因
    res.status(500).json({ message: '登录失败，请稍后再试' });
  }
};

// 获取当前用户信息
export const getCurrentUser = async (req, res) => {
  try {
    // req.user是通过auth中间件添加的
    const userInfo = {
      id: req.user.id,
      name: req.user.name,
      account: req.user.account,
      email: req.user.email,
      phone: req.user.phone,
      avatar: req.user.avatar,
      gender: req.user.gender,
      birth: req.user.birth
    };
    res.json(userInfo);
  } catch (error) {
    console.error('获取用户信息错误:', error);
    res.status(500).json({ message: '获取用户信息失败' });
  }
};

// 验证账号是否可用
export const validateAccount = async (req, res) => {
  try {
    const { account } = req.query;

    if (!account) {
      return res.status(400).json({ message: '请提供账号' });
    }

    if (!isValidAccount(account)) {
      return res.status(400).json({
        valid: false,
        message: '账号格式不正确，只能包含数字字符，长度8-12位'
      });
    }

    const existingUser = await User.findOne({ account });

    res.json({
      valid: !existingUser,
      message: existingUser ? '该账号已被使用' : '账号可用'
    });
  } catch (error) {
    console.error('验证账号错误:', error);
    res.status(500).json({ message: '验证失败' });
  }
};

// 验证邮箱是否可用
export const validateEmail = async (req, res) => {
  try {
    const { email } = req.query;

    if (!email) {
      return res.status(400).json({ message: '请提供邮箱' });
    }

    if (!isValidEmail(email)) {
      return res.status(400).json({
        valid: false,
        message: '邮箱格式不正确'
      });
    }

    const existingUser = await User.findOne({ email });

    res.json({
      valid: !existingUser,
      message: existingUser ? '该邮箱已被使用' : '邮箱可用'
    });
  } catch (error) {
    console.error('验证邮箱错误:', error);
    res.status(500).json({ message: '验证失败' });
  }
};

// 更新用户信息
export const updateUser = async (req, res) => {
  try {
    const { name, phone, avatar, gender, birth } = req.body;

    // 更新用户信息
    const user = await User.findByIdAndUpdate(
      req.user._id,
      { name, phone, avatar, gender, birth },
      { new: true, runValidators: true }
    );

    res.json(user);
  } catch (error) {
    res.status(500).json({ message: '服务器错误', error: error.message });
  }
};